home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #11 / Amiga Plus CD - 2002 - No. 11.iso / Tools / Development / TinyGL / ami / content / ad709 / tinygl / src / api_functions.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-15  |  10.8 KB  |  673 lines
  1. /*$T api_functions.c GC 1.137 08/09/02 17:47:18 */
  2.  
  3. /*$6
  4.  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  5.  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  6.  */
  7.  
  8. #include "zgl.h"
  9. #include <stdio.h>
  10.  
  11. /* glVertex */
  12. void GLAPIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
  13.     GLParam p[5];
  14.     /*~~~~~~~~~*/
  15.  
  16.     p[0].op = OP_Vertex;
  17.     p[1].f = x;
  18.     p[2].f = y;
  19.     p[3].f = z;
  20.     p[4].f = w;
  21.     gl_add_op(p);
  22. }
  23.  
  24. /* */
  25. void GLAPIENTRY glVertex2f(GLfloat x, GLfloat y) {
  26.     glVertex4f(x, y, 0, 1);
  27. }
  28.  
  29. /* */
  30. void GLAPIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
  31.     glVertex4f(x, y, z, 1);
  32. }
  33.  
  34. /* */
  35. void GLAPIENTRY glVertex3fv(const GLfloat *v) {
  36.     glVertex4f(v[0], v[1], v[2], 1);
  37. }
  38.  
  39. /* glNormal */
  40. void GLAPIENTRY glNormal3f(GLfloat x, GLfloat y, GLfloat z) {
  41.     GLParam p[4];
  42.     /*~~~~~~~~~*/
  43.  
  44.     p[0].op = OP_Normal;
  45.     p[1].f = x;
  46.     p[2].f = y;
  47.     p[3].f = z;
  48.  
  49.     gl_add_op(p);
  50. }
  51.  
  52. /* */
  53. void GLAPIENTRY glNormal3fv(const GLfloat *v) {
  54.     glNormal3f(v[0], v[1], v[2]);
  55. }
  56.  
  57. /* glColor */
  58. void GLAPIENTRY glColor4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
  59.     GLParam p[8];
  60.     /*~~~~~~~~~*/
  61.  
  62.     p[0].op = OP_Color;
  63.     p[1].f = r;
  64.     p[2].f = g;
  65.     p[3].f = b;
  66.     p[4].f = a;
  67.  
  68.     /* direct convertion to integer to go faster if no shading */
  69.     p[5].ui = (unsigned int) (r * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + ZB_POINT_RED_MIN);
  70.     p[6].ui = (unsigned int) (g * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + ZB_POINT_GREEN_MIN);
  71.     p[7].ui = (unsigned int) (b * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + ZB_POINT_BLUE_MIN);
  72.     gl_add_op(p);
  73. }
  74.  
  75. /* */
  76. void GLAPIENTRY glColor4fv(const GLfloat *v) {
  77.     GLParam p[8];
  78.     /*~~~~~~~~~*/
  79.  
  80.     p[0].op = OP_Color;
  81.     p[1].f = v[0];
  82.     p[2].f = v[1];
  83.     p[3].f = v[2];
  84.     p[4].f = v[3];
  85.  
  86.     /* direct convertion to integer to go faster if no shading */
  87.     p[5].ui = (unsigned int) (v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + ZB_POINT_RED_MIN);
  88.     p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + ZB_POINT_GREEN_MIN);
  89.     p[7].ui = (unsigned int) (v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + ZB_POINT_BLUE_MIN);
  90.     gl_add_op(p);
  91. }
  92.  
  93. /* */
  94. void GLAPIENTRY glColor3f(GLfloat x, GLfloat y, GLfloat z) {
  95.     glColor4f(x, y, z, 1);
  96. }
  97.  
  98. /* */
  99. void GLAPIENTRY glColor3fv(const GLfloat *v) {
  100.     glColor4f(v[0], v[1], v[2], 1);
  101. }
  102.  
  103. /* TexCoord */
  104. void GLAPIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
  105.     GLParam p[5];
  106.     /*~~~~~~~~~*/
  107.  
  108.     p[0].op = OP_TexCoord;
  109.     p[1].f = s;
  110.     p[2].f = t;
  111.     p[3].f = r;
  112.     p[4].f = q;
  113.  
  114.     gl_add_op(p);
  115. }
  116.  
  117. /* */
  118. void GLAPIENTRY glTexCoord2f(GLfloat s, GLfloat t) {
  119.     glTexCoord4f(s, t, 0, 1);
  120. }
  121.  
  122. /* */
  123. void GLAPIENTRY glTexCoord2fv(const GLfloat *v) {
  124.     glTexCoord4f(v[0], v[1], 0, 1);
  125. }
  126.  
  127. /* */
  128. void GLAPIENTRY glEdgeFlag(GLboolean flag) {
  129.     GLParam p[2];
  130.     /*~~~~~~~~~*/
  131.  
  132.     p[0].op = OP_EdgeFlag;
  133.     p[1].i = flag;
  134.     gl_add_op(p);
  135. }
  136.  
  137. /* misc */
  138. void GLAPIENTRY glShadeModel(GLenum mode) {
  139.     GLParam p[2];
  140.     /*~~~~~~~~~*/
  141.  
  142.     assert(mode == GL_FLAT || mode == GL_SMOOTH);
  143.     p[0].op = OP_ShadeModel;
  144.     p[1].i = mode;
  145.     gl_add_op(p);
  146. }
  147.  
  148. /* */
  149. void GLAPIENTRY glCullFace(GLenum mode) {
  150.     GLParam p[2];
  151.     /*~~~~~~~~~*/
  152.  
  153.     assert(mode == GL_BACK || mode == GL_FRONT || mode == GL_FRONT_AND_BACK);
  154.     p[0].op = OP_CullFace;
  155.     p[1].i = mode;
  156.     gl_add_op(p);
  157. }
  158.  
  159. /* */
  160. void GLAPIENTRY glFrontFace(GLenum mode) {
  161.     GLParam p[2];
  162.     /*~~~~~~~~~*/
  163.  
  164.     assert(mode == GL_CCW || mode == GL_CW);
  165.     mode = (mode != GL_CCW);
  166.     p[0].op = OP_FrontFace;
  167.     p[1].i = mode;
  168.     gl_add_op(p);
  169. }
  170.  
  171. /* */
  172. void GLAPIENTRY glPolygonMode(GLenum face, GLenum mode) {
  173.     GLParam p[3];
  174.     /*~~~~~~~~~*/
  175.  
  176.     assert(face == GL_BACK || face == GL_FRONT || face == GL_FRONT_AND_BACK);
  177.     assert(mode == GL_POINT || mode == GL_LINE || mode == GL_FILL);
  178.  
  179.     p[0].op = OP_PolygonMode;
  180.     p[1].i = face;
  181.     p[2].i = mode;
  182.  
  183.     gl_add_op(p);
  184. }
  185.  
  186. /* */
  187. void GLAPIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor) {
  188.     GLParam p[3];
  189.     /*~~~~~~~~~*/
  190.  
  191.     p[0].op = OP_BlendFunc;
  192.     p[1].i = sfactor;
  193.     p[2].i = dfactor;
  194.  
  195.     gl_add_op(p);
  196. }
  197.  
  198. /* glEnable / glDisable */
  199. void GLAPIENTRY glEnable(GLenum cap) {
  200.     GLParam p[3];
  201.     /*~~~~~~~~~*/
  202.  
  203.     p[0].op = OP_EnableDisable;
  204.     p[1].i = cap;
  205.     p[2].i = 1;
  206.  
  207.     gl_add_op(p);
  208. }
  209.  
  210. /* */
  211. void GLAPIENTRY glDisable(GLenum cap) {
  212.     GLParam p[3];
  213.     /*~~~~~~~~~*/
  214.  
  215.     p[0].op = OP_EnableDisable;
  216.     p[1].i = cap;
  217.     p[2].i = 0;
  218.  
  219.     gl_add_op(p);
  220. }
  221.  
  222. /* glBegin / glEnd */
  223. void GLAPIENTRY glBegin(GLenum mode) {
  224.     GLParam p[2];
  225.     /*~~~~~~~~~*/
  226.  
  227.     p[0].op = OP_Begin;
  228.     p[1].i = mode;
  229.  
  230.     gl_add_op(p);
  231. }
  232.  
  233. /* */
  234. void GLAPIENTRY glEnd(void) {
  235.     GLParam p[1];
  236.     /*~~~~~~~~~*/
  237.  
  238.     p[0].op = OP_End;
  239.  
  240.     gl_add_op(p);
  241. }
  242.  
  243. /* matrix */
  244. void GLAPIENTRY glMatrixMode(GLenum mode) {
  245.     GLParam p[2];
  246.     /*~~~~~~~~~*/
  247.  
  248.     p[0].op = OP_MatrixMode;
  249.     p[1].i = mode;
  250.  
  251.     gl_add_op(p);
  252. }
  253.  
  254. /* */
  255. void GLAPIENTRY glLoadMatrixf(const GLfloat *m) {
  256.     GLParam p[17];
  257.     int        i;
  258.     /*~~~~~~~~~~*/
  259.  
  260.     p[0].op = OP_LoadMatrix;
  261.     for(i = 0; i < 16; i++) {
  262.         p[i + 1].f = m[i];
  263.     }
  264.  
  265.     gl_add_op(p);
  266. }
  267.  
  268. /* */
  269. void GLAPIENTRY glLoadIdentity(void) {
  270.     GLParam p[1];
  271.  
  272.     p[0].op = OP_LoadIdentity;
  273.  
  274.     gl_add_op(p);
  275. }
  276.  
  277. /* */
  278. void GLAPIENTRY glMultMatrixf(const GLfloat *m) {
  279.     GLParam p[17];
  280.     int        i;
  281.  
  282.     p[0].op = OP_MultMatrix;
  283.     for(i = 0; i < 16; i++) {
  284.         p[i + 1].f = m[i];
  285.     }
  286.  
  287.     gl_add_op(p);
  288. }
  289.  
  290. /* */
  291. void GLAPIENTRY glPushMatrix(void) {
  292.     GLParam p[1];
  293.  
  294.     p[0].op = OP_PushMatrix;
  295.  
  296.     gl_add_op(p);
  297. }
  298.  
  299. /* */
  300. void GLAPIENTRY glPopMatrix(void) {
  301.     GLParam p[1];
  302.  
  303.     p[0].op = OP_PopMatrix;
  304.  
  305.     gl_add_op(p);
  306. }
  307.  
  308. /* */
  309. void GLAPIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
  310.     GLParam p[5];
  311.  
  312.     p[0].op = OP_Rotate;
  313.     p[1].f = angle;
  314.     p[2].f = x;
  315.     p[3].f = y;
  316.     p[4].f = z;
  317.  
  318.     gl_add_op(p);
  319. }
  320.  
  321. /* */
  322. void GLAPIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
  323.     GLParam p[4];
  324.  
  325.     p[0].op = OP_Translate;
  326.     p[1].f = x;
  327.     p[2].f = y;
  328.     p[3].f = z;
  329.  
  330.     gl_add_op(p);
  331. }
  332.  
  333. /* */
  334. void GLAPIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z) {
  335.     GLParam p[4];
  336.  
  337.     p[0].op = OP_Scale;
  338.     p[1].f = x;
  339.     p[2].f = y;
  340.     p[3].f = z;
  341.  
  342.     gl_add_op(p);
  343. }
  344.  
  345. /* */
  346. void GLAPIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
  347.     GLParam p[5];
  348.  
  349.     p[0].op = OP_Viewport;
  350.     p[1].i = x;
  351.     p[2].i = y;
  352.     p[3].i = width;
  353.     p[4].i = height;
  354.  
  355.     gl_add_op(p);
  356. }
  357.  
  358. /* */
  359. void GLAPIENTRY glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near,
  360.                           GLdouble farv) {
  361.     GLParam p[7];
  362.  
  363.     p[0].op = OP_Frustum;
  364.     p[1].f = left;
  365.     p[2].f = right;
  366.     p[3].f = bottom;
  367.     p[4].f = top;
  368.     p[5].f = near;
  369.     p[6].f = farv;
  370.  
  371.     gl_add_op(p);
  372. }
  373.  
  374. /* lightening */
  375. void GLAPIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
  376.     GLParam p[7];
  377.     int        i, n;
  378.  
  379.     assert(face == GL_FRONT || face == GL_BACK || face == GL_FRONT_AND_BACK);
  380.  
  381.     p[0].op = OP_Material;
  382.     p[1].i = face;
  383.     p[2].i = pname;
  384.     n = 4;
  385.     if(pname == GL_SHININESS) {
  386.         n = 1;
  387.     }
  388.  
  389.     for(i = 0; i < 4; i++) {
  390.         p[3 + i].f = params[i];
  391.     }
  392.  
  393.     for(i = n; i < 4; i++) {
  394.         p[3 + i].f = 0;
  395.     }
  396.  
  397.     gl_add_op(p);
  398. }
  399.  
  400. /* */
  401. void GLAPIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param) {
  402.     GLParam p[7];
  403.     int        i;
  404.  
  405.     p[0].op = OP_Material;
  406.     p[1].i = face;
  407.     p[2].i = pname;
  408.     p[3].f = param;
  409.     for(i = 0; i < 3; i++) {
  410.         p[4 + i].f = 0;
  411.     }
  412.  
  413.     gl_add_op(p);
  414. }
  415.  
  416. /* */
  417. void GLAPIENTRY glColorMaterial(GLenum face, GLenum mode) {
  418.     GLParam p[3];
  419.  
  420.     p[0].op = OP_ColorMaterial;
  421.     p[1].i = face;
  422.     p[2].i = mode;
  423.  
  424.     gl_add_op(p);
  425. }
  426.  
  427. /* */
  428. void GLAPIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params) {
  429.     GLParam p[7];
  430.     int        i;
  431.  
  432.     p[0].op = OP_Light;
  433.     p[1].i = light;
  434.     p[2].i = pname;
  435.  
  436.     /* TODO: 3 composants ? */
  437.     for(i = 0; i < 4; i++) {
  438.         p[3 + i].f = params[i];
  439.     }
  440.  
  441.     gl_add_op(p);
  442. }
  443.  
  444. /* */
  445. void GLAPIENTRY glLightf(GLenum light, GLenum pname, GLfloat param) {
  446.     GLParam p[7];
  447.     int        i;
  448.  
  449.     p[0].op = OP_Light;
  450.     p[1].i = light;
  451.     p[2].i = pname;
  452.     p[3].f = param;
  453.     for(i = 0; i < 3; i++) {
  454.         p[4 + i].f = 0;
  455.     }
  456.  
  457.     gl_add_op(p);
  458. }
  459.  
  460. /* */
  461. void GLAPIENTRY glLightModeli(GLenum pname, GLint param) {
  462.     GLParam p[6];
  463.     int        i;
  464.  
  465.     p[0].op = OP_LightModel;
  466.     p[1].i = pname;
  467.     p[2].f = (GLfloat) param;
  468.     for(i = 0; i < 4; i++) {
  469.         p[3 + i].f = 0;
  470.     }
  471.  
  472.     gl_add_op(p);
  473. }
  474.  
  475. /* */
  476. void GLAPIENTRY glLightModelfv(GLenum pname, const GLfloat *params) {
  477.     GLParam p[6];
  478.     int        i;
  479.  
  480.     p[0].op = OP_LightModel;
  481.     p[1].i = pname;
  482.     for(i = 0; i < 4; i++) {
  483.         p[2 + i].f = params[i];
  484.     }
  485.  
  486.     gl_add_op(p);
  487. }
  488.  
  489. /* clear */
  490. void GLAPIENTRY glClear(GLbitfield mask) {
  491.     GLParam p[2];
  492.  
  493.     p[0].op = OP_Clear;
  494.     p[1].i = mask;
  495.  
  496.     gl_add_op(p);
  497. }
  498.  
  499. /* */
  500. void GLAPIENTRY glClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
  501.     GLParam p[5];
  502.  
  503.     p[0].op = OP_ClearColor;
  504.     p[1].f = r;
  505.     p[2].f = g;
  506.     p[3].f = b;
  507.     p[4].f = a;
  508.  
  509.     gl_add_op(p);
  510. }
  511.  
  512. /* */
  513. void GLAPIENTRY glClearDepth(GLdouble depth) {
  514.     GLParam p[2];
  515.  
  516.     p[0].op = OP_ClearDepth;
  517.     p[1].f = depth;
  518.  
  519.     gl_add_op(p);
  520. }
  521.  
  522. /* textures */
  523. void GLAPIENTRY glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width,
  524.                              GLsizei height, GLint border, GLenum format, GLenum type,
  525.                              const GLvoid *pixels) {
  526.     GLParam p[10];
  527.  
  528.     p[0].op = OP_TexImage2D;
  529.     p[1].i = target;
  530.     p[2].i = level;
  531.     p[3].i = internalFormat;
  532.     p[4].i = width;
  533.     p[5].i = height;
  534.     p[6].i = border;
  535.     p[7].i = format;
  536.     p[8].i = type;
  537.     p[9].p = (GLvoid *) pixels;
  538.  
  539.     gl_add_op(p);
  540. }
  541.  
  542. /* */
  543. void GLAPIENTRY glBindTexture(GLenum target, GLuint texture) {
  544.     GLParam p[3];
  545.  
  546.     p[0].op = OP_BindTexture;
  547.     p[1].i = target;
  548.     p[2].i = texture;
  549.  
  550.     gl_add_op(p);
  551. }
  552.  
  553. /* */
  554. void GLAPIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param) {
  555.     GLParam p[8];
  556.  
  557.     p[0].op = OP_TexEnv;
  558.     p[1].i = target;
  559.     p[2].i = pname;
  560.     p[3].i = param;
  561.     p[4].f = 0;
  562.     p[5].f = 0;
  563.     p[6].f = 0;
  564.     p[7].f = 0;
  565.  
  566.     gl_add_op(p);
  567. }
  568.  
  569. /* */
  570. void GLAPIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param) {
  571.     GLParam p[8];
  572.  
  573.     p[0].op = OP_TexParameter;
  574.     p[1].i = target;
  575.     p[2].i = pname;
  576.     p[3].i = param;
  577.     p[4].f = 0;
  578.     p[5].f = 0;
  579.     p[6].f = 0;
  580.     p[7].f = 0;
  581.  
  582.     gl_add_op(p);
  583. }
  584.  
  585. /* */
  586. void GLAPIENTRY glPixelStorei(GLenum pname, GLint param) {
  587.     GLParam p[3];
  588.  
  589.     p[0].op = OP_PixelStore;
  590.     p[1].i = pname;
  591.     p[2].i = param;
  592.  
  593.     gl_add_op(p);
  594. }
  595.  
  596. /* selection */
  597. void GLAPIENTRY glInitNames(void) {
  598.     GLParam p[1];
  599.  
  600.     p[0].op = OP_InitNames;
  601.  
  602.     gl_add_op(p);
  603. }
  604.  
  605. /* */
  606. void GLAPIENTRY glPushName(GLuint name) {
  607.     GLParam p[2];
  608.  
  609.     p[0].op = OP_PushName;
  610.     p[1].i = name;
  611.  
  612.     gl_add_op(p);
  613. }
  614.  
  615. /* */
  616. void GLAPIENTRY glPopName(void) {
  617.     GLParam p[1];
  618.  
  619.     p[0].op = OP_PopName;
  620.  
  621.     gl_add_op(p);
  622. }
  623.  
  624. /* */
  625. void GLAPIENTRY glLoadName(GLuint name) {
  626.     GLParam p[2];
  627.  
  628.     p[0].op = OP_LoadName;
  629.     p[1].i = name;
  630.  
  631.     gl_add_op(p);
  632. }
  633.  
  634. /* */
  635. void GLAPIENTRY glPolygonOffset(GLfloat factor, GLfloat units) {
  636.     GLParam p[3];
  637.     p[0].op = OP_PolygonOffset;
  638.     p[1].f = factor;
  639.     p[2].f = units;
  640. }
  641.  
  642. /* Special Functions */
  643. void GLAPIENTRY glCallList(GLuint list) {
  644.     GLParam p[2];
  645.  
  646.     p[0].op = OP_CallList;
  647.     p[1].i = list;
  648.  
  649.     gl_add_op(p);
  650. }
  651.  
  652. /* */
  653. void GLAPIENTRY glFlush(void) {
  654.     /* nothing to do */
  655. }
  656.  
  657. /* */
  658. void GLAPIENTRY glHint(GLenum target, GLenum mode) {
  659.     GLParam p[3];
  660.  
  661.     p[0].op = OP_Hint;
  662.     p[1].i = target;
  663.     p[2].i = mode;
  664.  
  665.     gl_add_op(p);
  666. }
  667.  
  668. /* Non standard functions */
  669. void glDebug(int mode) {
  670.     GLContext    *c = gl_get_context();
  671.     c->print_flag = mode;
  672. }
  673.